/**
 * 购物车数据管理工具
 */

import { convertToHttpsImageUrl } from './imageUtils.js'

const CART_STORAGE_KEY = 'cartItems';

/**
 * 购物车管理类
 */
class CartManager {
  /**
   * 获取购物车数据
   * @returns {Array} 购物车商品列表
   */
  static getCartItems() {
    try {
      const cartItems = uni.getStorageSync(CART_STORAGE_KEY);
      return Array.isArray(cartItems) ? cartItems : [];
    } catch (error) {
      console.error('获取购物车数据失败:', error);
      return [];
    }
  }

  /**
   * 保存购物车数据
   * @param {Array} cartItems - 购物车商品列表
   */
  static saveCartItems(cartItems) {
    try {
      uni.setStorageSync(CART_STORAGE_KEY, cartItems);
      return true;
    } catch (error) {
      console.error('保存购物车数据失败:', error);
      return false;
    }
  }

  /**
   * 添加商品到购物车
   * @param {Object} product - 商品信息
   * @param {number} quantity - 数量
   * @returns {boolean} 是否添加成功
   */
  static addToCart(product, quantity = 1) {
    try {
      const cartItems = this.getCartItems();
      
      // 检查商品是否已存在
      const existingIndex = cartItems.findIndex(item => item.id === product.id);
      
      if (existingIndex >= 0) {
        // 商品已存在，增加数量
        cartItems[existingIndex].quantity += quantity;
      } else {
        // 新商品，添加到购物车
        const cartItem = {
          id: product.id,
          name: product.name,
          price: product.price,
          image: convertToHttpsImageUrl(product.main_image_url || product.image),
          specification: product.category_name || product.specification || '默认规格',
          quantity: quantity,
          selected: true
        };
        cartItems.push(cartItem);
      }
      
      return this.saveCartItems(cartItems);
    } catch (error) {
      console.error('添加到购物车失败:', error);
      return false;
    }
  }

  /**
   * 更新购物车商品数量
   * @param {number} productId - 商品ID
   * @param {number} quantity - 新数量
   * @returns {boolean} 是否更新成功
   */
  static updateQuantity(productId, quantity) {
    try {
      const cartItems = this.getCartItems();
      const index = cartItems.findIndex(item => item.id === productId);
      
      if (index >= 0) {
        if (quantity <= 0) {
          // 数量为0或负数，删除商品
          cartItems.splice(index, 1);
        } else {
          cartItems[index].quantity = quantity;
        }
        return this.saveCartItems(cartItems);
      }
      
      return false;
    } catch (error) {
      console.error('更新商品数量失败:', error);
      return false;
    }
  }

  /**
   * 删除购物车商品
   * @param {number} productId - 商品ID
   * @returns {boolean} 是否删除成功
   */
  static removeFromCart(productId) {
    try {
      const cartItems = this.getCartItems();
      const filteredItems = cartItems.filter(item => item.id !== productId);
      return this.saveCartItems(filteredItems);
    } catch (error) {
      console.error('删除购物车商品失败:', error);
      return false;
    }
  }

  /**
   * 切换商品选中状态
   * @param {number} productId - 商品ID
   * @param {boolean} selected - 选中状态
   * @returns {boolean} 是否更新成功
   */
  static toggleItemSelect(productId, selected = null) {
    try {
      const cartItems = this.getCartItems();
      const index = cartItems.findIndex(item => item.id === productId);
      
      if (index >= 0) {
        cartItems[index].selected = selected !== null ? selected : !cartItems[index].selected;
        return this.saveCartItems(cartItems);
      }
      
      return false;
    } catch (error) {
      console.error('切换商品选中状态失败:', error);
      return false;
    }
  }

  /**
   * 全选/取消全选
   * @param {boolean} selectAll - 是否全选
   * @returns {boolean} 是否更新成功
   */
  static toggleSelectAll(selectAll) {
    try {
      const cartItems = this.getCartItems();
      cartItems.forEach(item => {
        item.selected = selectAll;
      });
      return this.saveCartItems(cartItems);
    } catch (error) {
      console.error('全选/取消全选失败:', error);
      return false;
    }
  }

  /**
   * 清空购物车
   * @returns {boolean} 是否清空成功
   */
  static clearCart() {
    try {
      return this.saveCartItems([]);
    } catch (error) {
      console.error('清空购物车失败:', error);
      return false;
    }
  }

  /**
   * 获取购物车统计信息
   * @returns {Object} 统计信息
   */
  static getCartStats() {
    try {
      const cartItems = this.getCartItems();
      const selectedItems = cartItems.filter(item => item.selected);
      
      return {
        totalItems: cartItems.length,
        selectedItems: selectedItems.length,
        totalQuantity: cartItems.reduce((sum, item) => sum + item.quantity, 0),
        selectedQuantity: selectedItems.reduce((sum, item) => sum + item.quantity, 0),
        totalPrice: selectedItems.reduce((sum, item) => sum + (item.price * item.quantity), 0),
        isAllSelected: cartItems.length > 0 && cartItems.every(item => item.selected)
      };
    } catch (error) {
      console.error('获取购物车统计信息失败:', error);
      return {
        totalItems: 0,
        selectedItems: 0,
        totalQuantity: 0,
        selectedQuantity: 0,
        totalPrice: 0,
        isAllSelected: false
      };
    }
  }

  /**
   * 获取选中的商品列表
   * @returns {Array} 选中的商品列表
   */
  static getSelectedItems() {
    try {
      const cartItems = this.getCartItems();
      return cartItems.filter(item => item.selected);
    } catch (error) {
      console.error('获取选中商品失败:', error);
      return [];
    }
  }

  /**
   * 检查商品是否在购物车中
   * @param {number} productId - 商品ID
   * @returns {boolean} 是否在购物车中
   */
  static isInCart(productId) {
    try {
      const cartItems = this.getCartItems();
      return cartItems.some(item => item.id === productId);
    } catch (error) {
      console.error('检查商品是否在购物车中失败:', error);
      return false;
    }
  }

  /**
   * 获取商品在购物车中的数量
   * @param {number} productId - 商品ID
   * @returns {number} 商品数量
   */
  static getProductQuantity(productId) {
    try {
      const cartItems = this.getCartItems();
      const item = cartItems.find(item => item.id === productId);
      return item ? item.quantity : 0;
    } catch (error) {
      console.error('获取商品数量失败:', error);
      return 0;
    }
  }
}

// ES6 模块导出
export default CartManager;
export { CartManager };
